use std::{sync::{Arc, RwLock}, thread, time::Duration};
use std::thread::sleep;

pub mod date_utils;
pub mod timimg_utils;
pub mod scheduled;

use timimg_utils::Timing;
use scheduled::Scheduled;
pub fn test_date() {
    // // 获取当前时间
    // date_utils::get_now_time();

    // // 获取当前的时间戳
    // println!("当前的毫秒 {:?}", date_utils::get_now_millis());
    // println!("当前的时间戳 {:?}", date_utils::get_now_stamp());
    // // 时间戳转日期
    // println!("时间戳转日期1 {:?}", date_utils::stamp_date(1722310378));
    // println!("时间戳转日期2 {:?}", date_utils::stamp_date(1722310378000));

    // // 按照时间格式打印

    // // String 转 时间类
    // println!("打印信息： {:?}", date_utils::str_to_date("2025-12-24 12:02:17"));
    // // 时间类 转 String

    // // 时间间隔，1天 1月

    // ----------------?
    // 计数工作
    // timimg_utils::create_timing(|temp|{
    //     println!("计数： {}",temp);
    // })

    // let tm = timimg_utils::Timing::new(2000);

    // thread::spawn(move || {
    //     tm.create(|st| {
    //         println!("计数： {}", st);
    //     });
    // });
    // println!("计数： 已经开始了吧");
    // thread::sleep(Duration::from_secs(3));
    // println!("计数： 睡够了3秒");



    // {
    //     tm01.write().unwrap().pause();
    //     println!("计数： 改变了调用");
    // }

    // let mut tm2 = timimg_utils::Timing::new(1000);
    // tm2.create(move |st: u64| {
    //     println!("计数002： {}", st);
    //     if st > 4 * 1000 {
    //         tm01.lock().unwrap().pause();
    //     }
    // });

    // let tm = timimg_utils::Timing::new(1);
    // tm.create(|_st|{});

    // thread::sleep(Duration::from_secs(5));
    // let tm = Arc::new(RwLock::new(Timing::new(1)));
    // let  temp =  Arc::new(RwLock::new(0));
    // let tm01 = tm.clone();
    // thread::spawn(move ||{
    //     loop {
    //         thread::sleep(Duration::from_secs(1));
    //         *temp.write().unwrap() +=1;
    //         if !tm.read().unwrap().get_loop() {
    //              break;
    //         }
    //         println!("打印数据： {:?}", temp)
    //     }
    // });
    //
    // thread::sleep(Duration::from_secs(5));
    // tm01.write().unwrap().pause();

   // let rt = tokio::runtime::Builder::new_multi_thread()
   //      .worker_threads(3)
   //      .enable_all()
   //      .build()
   //      .expect("线程创建失败");
   //  rt.block_on(async {
   //     let mut sched = Scheduled::build(1,false);
   //      sched.time_ling(60, 0);
   //      sched.start_build(|temp|{
   //          println!("打印输出 block_on： {}",temp)
   //      }).await;
   //
   //      println!("当前时间： {:?}",std::time::SystemTime::now());
   //      scheduled::post_deylay(||{
   //          println!("延时后时间： {:?}",std::time::SystemTime::now());
   //      }, 2000).await;
   //
   //      sleep(Duration::from_secs(4));
   //      sched.finished();
   //      println!("结束了");
   //      sleep(Duration::from_secs(2));
   //  });
   //  println!("线程结束了");
   //  thread::sleep(Duration::from_secs(2));


    let rt = tokio::runtime::Builder::new_multi_thread()
         .worker_threads(3)
         .enable_all()
         .build()
         .expect("线程创建失败");

    rt.block_on(async {

        let (tx, mut rx) = tokio::sync::mpsc::channel(1);
        tokio::spawn(async move {
            let mut temp = 0;
            loop {
                tokio::time::sleep(Duration::from_secs(1)).await;
                temp +=1;
                tx.send(temp).await.unwrap()
            }

        });
        println!("打印数据：开始");

       let task = async {
            loop {
                let data = rx.recv().await;
                println!("打印数据：data: {:?}", data);
            }
        };
        println!("打印数据：结束");
        task.await;
        sleep(Duration::from_secs(10));
    });

}
